Stock Price Predictions Using Ridge regression & LSTM¶
OUAHMANE TARIQ¶
1: UNDERSTAND THE PROBLEM STATEMENT & BUSINESS CASE¶
2: IMPORT DATASETS AND LIBRARIES¶
In [12]:
import pandas as pd
import plotly.express as px
from copy import copy
from scipy import stats
import matplotlib.pyplot as plt
import numpy as np
import plotly.figure_factory as ff
from sklearn.linear_model import LinearRegression
from sklearn.svm import SVR
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
from tensorflow import keras
In [13]:
# Read stock prices data
stock_price_df = pd.read_csv('stock.csv')
stock_price_df
Out[13]:
In [14]:
# Read the stocks volume data
stock_vol_df = pd.read_csv("stock_volume.csv")
stock_vol_df
Out[14]:
In [15]:
# Check if Null values exist in stock prices data
stock_price_df.isnull().sum()
Out[15]:
In [16]:
# Check if Null values exist in stocks volume data
stock_vol_df.isnull().sum()
Out[16]:
In [17]:
# Get stock prices dataframe info
stock_price_df.info()
In [18]:
# Get stock volume dataframe info
stock_vol_df.info()
In [19]:
stock_vol_df.describe()
Out[19]:
3: PERFORM EXPLORATORY DATA ANALYSIS AND VISUALIZATION¶
In [20]:
# Function to normalize stock prices based on their initial price
def normalize(df):
x = df.copy()
for i in x.columns[1:]:
x[i] = x[i]/x[i][0]
return x
In [21]:
# Function to plot interactive plots using Plotly Express
def interactive_plot(df, title):
fig = px.line(title = title)
for i in df.columns[1:]:
fig.add_scatter(x = df['Date'], y = df[i], name = i)
fig.show()
In [22]:
# plot interactive chart for stocks data
interactive_plot(stock_price_df, 'Stock Prices')
4: PREPARE THE DATA BEFORE TRAINING THE AI/ML MODEL¶
In [23]:
# Function to concatenate the date, stock price, and volume in one dataframe
def individual_stock(price_df, vol_df, name):
return pd.DataFrame({'Date': price_df['Date'], 'Close': price_df[name], 'Volume': vol_df[name]})
In [24]:
# Function to return the input/output (target) data for AI/ML Model
# Note that our goal is to predict the future stock price
# Target stock price today will be tomorrow's price
def trading_window(data):
# 1 day window
n = 1
# Create a column containing the prices for the next 1 days
data['Target'] = data[['Close']].shift(-n)
# return the new dataset
return data
In [25]:
# Let's test the functions and get individual stock prices and volumes for AAPL
price_volume_df = individual_stock(stock_price_df, stock_vol_df, 'AAPL')
price_volume_df
Out[25]:
In [26]:
price_volume_target_df = trading_window(price_volume_df)
price_volume_target_df
Out[26]:
In [27]:
# Remove the last row as it will be a null value
price_volume_target_df = price_volume_target_df[:-1]
price_volume_target_df
Out[27]:
In [28]:
# Scale the data
from sklearn.preprocessing import MinMaxScaler
sc = MinMaxScaler(feature_range = (0, 1))
price_volume_target_scaled_df = sc.fit_transform(price_volume_target_df.drop(columns = ['Date']))
In [29]:
#scaled Data
price_volume_target_scaled_df #close volume target
Out[29]:
In [30]:
price_volume_target_scaled_df.shape
Out[30]:
In [31]:
# Creating Feature and Target
# X : input of our model
# Y: output
X=price_volume_target_scaled_df[:,:2] #including the fisrt 2 columns closing and volume as input
y=price_volume_target_scaled_df[:,2:] # only target column
In [32]:
X
Out[32]:
In [33]:
y
Out[33]:
In [34]:
# Converting dataframe to arrays
# X = np.asarray(X)
# y = np.asarray(y)
X.shape, y.shape
Out[34]:
In [35]:
# Spliting the data this way, since order is important in time-series
# Note that we did not use train test split with it's default settings since it shuffles the data
split = int(0.65 * len(X))
X_train = X[:split]
y_train = y[:split]
X_test = X[split:]
y_test = y[split:]
In [36]:
X_train.shape, y_train.shape
Out[36]:
In [37]:
X_test.shape, y_test.shape
Out[37]:
In [38]:
# Define a data plotting function
def show_plot(data, title):
plt.figure(figsize = (13, 5))
plt.plot(data, linewidth = 3)
plt.title(title)
plt.grid()
show_plot(X_train, 'Training Data')
show_plot(X_test, 'Testing Data')
5: UNDERSTAND THE THEORY AND INTUITION BEHIND REGRESSION¶
TASK #6: UNDERSTAND THE CONCEPT OF REGULARIZATION & RIDGE REGRESSION¶
7: BUILD AND TRAIN A RIDGE LINEAR REGRESSION MODEL¶
In [39]:
from sklearn.linear_model import Ridge
# Note that Ridge regression performs linear least squares with L2 regularization.
# Create and train the Ridge Linear Regression Model
regression_model = Ridge()
regression_model.fit(X_train, y_train)
Out[39]:
In [40]:
# Test the model and calculate its accuracy
lr_accuracy = regression_model.score(X_test, y_test)
print("Linear Regression Score: ", lr_accuracy)
In [41]:
# Make Prediction
predicted_prices = regression_model.predict(X)
predicted_prices
Out[41]:
In [42]:
# Append the predicted values into a list
Predicted = []
for i in predicted_prices:
Predicted.append(i[0])
In [43]:
len(Predicted)
Out[43]:
In [44]:
# Append the close values to the list
close = []
for i in price_volume_target_scaled_df:
close.append(i[0])
In [45]:
# Create a dataframe based on the dates in the individual stock data
df_predicted = price_volume_target_df[['Date']]
df_predicted
Out[45]:
In [46]:
# Add the close values to the dataframe
df_predicted['Close'] = close
df_predicted
Out[46]:
In [47]:
# Add the predicted values to the dataframe
df_predicted['Prediction'] = Predicted
df_predicted
Out[47]:
In [48]:
# Plot the results
#the model perform well during the testing phase
interactive_plot(df_predicted, "Original Vs. Prediction")
8: UNDERSTAND THE THEORY AND INTUITION BEHIND NEURAL NETWORKS¶
9: UNDERSTAND HOW DO ARTFICIAL NEURAL NETWORKS TRAIN¶
10: UNDERSTAND THE THEORY AND INTUITION BEHIND RECURRENT NEURAL NETWORKS¶
11: UNDERSTAND THE THEORY AND INTUITION BEHIND LONG SHORT TERM MEMORY NETWORKS¶
12: TRAIN AN LSTM TIME SERIES MODEL¶
In [49]:
# Let's test the functions and get individual stock prices and volumes for AAPL
price_volume_df = individual_stock(stock_price_df, stock_vol_df, 'sp500')
price_volume_df
Out[49]:
In [50]:
# Get the close and volume data as training data (Input)
training_data = price_volume_df.iloc[:, 1:3].values
training_data
Out[50]:
In [51]:
# Normalize the data
from sklearn.preprocessing import MinMaxScaler
sc = MinMaxScaler(feature_range = (0, 1))
training_set_scaled = sc.fit_transform(training_data)
In [52]:
# Create the training and testing data, training data contains present day and previous day values
X = []
y = []
for i in range(1, len(price_volume_df)):
X.append(training_set_scaled [i-1:i, 0])
y.append(training_set_scaled [i, 0])
In [53]:
# Convert the data into array format
X = np.asarray(X)
y = np.asarray(y)
In [54]:
# Split the data
split = int(0.7 * len(X))
X_train = X[:split]
y_train = y[:split]
X_test = X[split:]
y_test = y[split:]
In [55]:
# Reshape the 1D arrays to 3D arrays to feed in the model
X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))
X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))
X_train.shape, X_test.shape
Out[55]:
In [56]:
# Create the model
inputs = keras.layers.Input(shape=(X_train.shape[1], X_train.shape[2]))
x = keras.layers.LSTM(150, return_sequences= True)(inputs)
x = keras.layers.Dropout(0.3)(x)
x = keras.layers.LSTM(150, return_sequences=True)(x)
x = keras.layers.Dropout(0.3)(x)
x = keras.layers.LSTM(150)(x)
outputs = keras.layers.Dense(1, activation='linear')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer='adam', loss="mse")
model.summary()
In [57]:
# Train the model
history = model.fit(
X_train, y_train,
epochs = 20,
batch_size = 32,
validation_split = 0.2
)
In [58]:
# Make prediction
predicted = model.predict(X)
In [59]:
# Append the predicted values to the list
test_predicted = []
for i in predicted:
test_predicted.append(i[0])
In [60]:
#create a new data frame and add date
df_predicted = price_volume_df[1:][['Date']]
df_predicted
Out[60]:
In [61]:
# add predected prices :
df_predicted['predections']=test_predicted
In [62]:
# add closing prices :
close=[]
for i in training_set_scaled:
close.append(i[0])
df_predicted['close'] = close[1:]
In [63]:
df_predicted.head()
Out[63]:
In [64]:
interactive_plot(df_predicted,"Original vs LSTM prediction")